ട്രാൻസ്ഫോർമർ ഡീകോഡ് ചെയ്യുന്നു: അറ്റൻഷൻ മെക്കാനിസം നടപ്പിലാക്കുന്നതിനെക്കുറിച്ച് ആഴത്തിലുള്ള പഠനം

2017-ൽ, ഗൂഗിൾ ബ്രെയിനിന്റെ "അറ്റൻഷൻ ഈസ് ഓൾ യു നീഡ്" എന്ന ഒരു ഗവേഷണ പ്രബന്ധം ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് ലോകത്തെ സമൂലമായി മാറ്റിമറിച്ചു. ഈ പ്രബന്ധം ട്രാൻസ്ഫോർമർ ആർക്കിടെക്ചർ അവതരിപ്പിച്ചു, ഇത് മുമ്പ് മെഷീൻ ട്രാൻസ്ലേഷൻ പോലുള്ള സീക്വൻസ്-അധിഷ്ഠിത ജോലികളിൽ ആധിപത്യം പുലർത്തിയിരുന്ന റിക്കറൻ്റ്, കൺവൊല്യൂഷണൽ ലെയറുകളെ പൂർണ്ണമായും ഒഴിവാക്കിയ ഒരു നൂതന ഡിസൈൻ ആയിരുന്നു. ഈ വിപ്ലവത്തിൻ്റെ ഹൃദയഭാഗത്ത് ശക്തവും എന്നാൽ ഗംഭീരവുമായ ഒരു ആശയമായിരുന്നു: അറ്റൻഷൻ മെക്കാനിസം.

ഇന്ന്, GPT-4, LLaMA പോലുള്ള വലിയ ഭാഷാ മോഡലുകൾ മുതൽ കമ്പ്യൂട്ടർ വിഷനിലും ഡ്രഗ് ഡിസ്കവറിയിലും ഉള്ള ഗ്രൗണ്ട്ബ്രേക്കിംഗ് മോഡലുകൾ വരെ, മിക്കവാറും എല്ലാ അത്യാധുനിക AI മോഡലുകളുടെയും അടിസ്ഥാന ശിലയാണ് ട്രാൻസ്ഫോർമറുകൾ. AI പ്രാക്ടീഷണർമാർക്ക് അറ്റൻഷൻ മെക്കാനിസം മനസ്സിലാക്കുന്നത് ഒരു ഓപ്ഷൻ അല്ല; അത് അത്യാവശ്യമാണ്. ഈ സമഗ്രമായ ഗൈഡ് ഡെവലപ്പർമാർ, ഡാറ്റാ സയൻ്റിസ്റ്റുകൾ, AI താൽപ്പര്യക്കാർ എന്നിവരടങ്ങിയ ഒരു ആഗോള പ്രേക്ഷകർക്കായി രൂപകൽപ്പന ചെയ്തതാണ്. അറ്റൻഷൻ മെക്കാനിസം ഞങ്ങൾ ലളിതമാക്കും, അതിൻ്റെ അടിസ്ഥാന തത്വങ്ങൾ മുതൽ കോഡിലെ പ്രായോഗിക നടപ്പാക്കൽ വരെ ഞങ്ങൾ അതിനെ വിഭജിക്കും. ആധുനിക AIയെ നയിക്കുന്ന എഞ്ചിൻ മനസ്സിലാക്കാനും നിർമ്മിക്കാനുമുള്ളIntution യും സാങ്കേതിക വൈദഗ്ധ്യവും നിങ്ങൾക്ക് നൽകുക എന്നതാണ് ഞങ്ങളുടെ ലക്ഷ്യം.

എന്താണ് അറ്റൻഷൻ? ഒരു ആഗോള Intution

മാട്രിക്സുകളിലേക്കും ഫോർമുലകളിലേക്കും കടക്കുന്നതിന് മുമ്പ്, നമുക്ക് ഒരു സാർവത്രിക Intution നിർമ്മിക്കാം. നിങ്ങൾ ഈ വാക്യം വായിക്കുന്നതായി സങ്കൽപ്പിക്കുക: "നിരവധി അന്താരാഷ്ട്ര തുറമുഖങ്ങളിൽ നിന്നുള്ള ചരക്കുകൾ കയറ്റിയ കപ്പൽ, സമുദ്രത്തിലൂടെ സുഗമമായി സഞ്ചരിച്ചു."

"സഞ്ചരിച്ചു" എന്ന വാക്കിൻ്റെ അർത്ഥം മനസ്സിലാക്കാൻ, നിങ്ങളുടെ തലച്ചോറ് വാക്യത്തിലെ മറ്റ് എല്ലാ വാക്കുകൾക്കും തുല്യമായ ഭാരം നൽകുന്നില്ല. ഇത് അബോധാവസ്ഥയിൽ "കപ്പൽ", "സമുദ്രം" എന്നിവയ്ക്ക് "ചരക്ക്" അല്ലെങ്കിൽ "തുറമുഖങ്ങൾ"യേക്കാൾ കൂടുതൽ ശ്രദ്ധ നൽകുന്നു. ഈ തിരഞ്ഞെടുക്കപ്പെട്ട ശ്രദ്ധ - ഒരു പ്രത്യേക ഘടകം പ്രോസസ്സ് ചെയ്യുമ്പോൾ വ്യത്യസ്ത വിവരങ്ങളുടെ പ്രാധാന്യം ഡൈനാമിക്കായി അളക്കാനുള്ള കഴിവ് - അറ്റൻഷൻ്റെ സത്തയാണ്.

AIയുടെ സന്ദർഭത്തിൽ, അറ്റൻഷൻ മെക്കാനിസം ഒരു മോഡലിന് ഇത് ചെയ്യാൻ അനുവദിക്കുന്നു. ഒരു ഇൻപുട്ട് സീക്വൻസിൻ്റെ ഒരു ഭാഗം പ്രോസസ്സ് ചെയ്യുമ്പോൾ (ഒരു വാക്യത്തിലെ ഒരു വാക്ക് അല്ലെങ്കിൽ ഒരു ചിത്രത്തിലെ ഒരു പാച്ച് പോലെ), അത് മുഴുവൻ സീക്വൻസും നോക്കാനും നിലവിലെ ഭാഗം മനസ്സിലാക്കാൻ മറ്റ് ഏത് ഭാഗങ്ങളാണ് ഏറ്റവും പ്രസക്തമെന്ന് തീരുമാനിക്കാനും കഴിയും. ഒരു റിക്കറൻ്റ് ചെയിനിലൂടെ തുടർച്ചയായി വിവരങ്ങൾ കൈമാറാതെ ദീർഘദൂര ആശ്രിതത്വത്തെ നേരിട്ട് മോഡൽ ചെയ്യാനുള്ള ഈ കഴിവാണ് ട്രാൻസ്ഫോർമറുകളെ ഇത്രയും ശക്തവും കാര്യക്ഷമവുമാക്കുന്നത്.

കോർ എഞ്ചിൻ: സ്കെയിൽഡ് ഡോട്ട്-പ്രൊഡക്റ്റ് അറ്റൻഷൻ

ട്രാൻസ്ഫോർമറുകളിൽ ഉപയോഗിക്കുന്ന ഏറ്റവും സാധാരണമായ അറ്റൻഷൻ രൂപം സ്കെയിൽഡ് ഡോട്ട്-പ്രൊഡക്റ്റ് അറ്റൻഷൻ എന്ന് അറിയപ്പെടുന്നു. അതിൻ്റെ ഫോർമുല ആദ്യം ഭയപ്പെടുത്തുന്നതായി തോന്നാം, പക്ഷേ അത് യുക്തിപരമായ ഘട്ടങ്ങളുടെ ഒരു പരമ്പരയിൽ നിർമ്മിച്ചതാണ്, അത് നമ്മുടെ Intution യുമായി മനോഹരമായി ബന്ധിപ്പിക്കുന്നു.

ഫോർമുല ഇതാണ്: Attention(Q, K, V) = softmax( (QK^T) / √d_k ) * V

നമുക്ക് ഇത് ഓരോന്നായി വിഭജിക്കാം, മൂന്ന് പ്രധാന ഇൻപുട്ടുകളിൽ നിന്ന് ആരംഭിക്കാം.

ട്രicylic: ക്വറി, കീ, മൂല്യം (Q, K, V)

അറ്റൻഷൻ നടപ്പിലാക്കാൻ, ഞങ്ങൾ ഇൻപുട്ട് ഡാറ്റ (ഉദാഹരണത്തിന്, വേഡ് എംബെഡിംഗുകൾ) മൂന്ന് വ്യത്യസ്ത പ്രതിനിധാനങ്ങളായി പരിവർത്തനം ചെയ്യുന്നു: ക്വറികൾ, കീകൾ, മൂല്യങ്ങൾ. ഇത് ഒരു പുനരാഗമന സംവിധാനം പോലെ ചിന്തിക്കുക, ഒരു ഡിജിറ്റൽ ലൈബ്രറിയിൽ വിവരങ്ങൾക്കായി തിരയുന്നത് പോലെ:

• ക്വറി (Q): നിങ്ങൾ ശ്രദ്ധിക്കുന്ന നിലവിലെ ഇനത്തെ ഇത് പ്രതിനിധീകരിക്കുന്നു. ഇത് നിങ്ങളുടെ ചോദ്യമാണ്. ഒരു പ്രത്യേക വാക്കിന്, അതിൻ്റെ ക്വറി വെക്റ്റർ ചോദിക്കുന്നു: "വാക്യത്തിലെ മറ്റെന്താണ് എനിക്ക് പ്രസക്തം?"
• കീ (K): സീക്വൻസിലെ ഓരോ ഇനത്തിനും ഒരു കീ വെക്റ്റർ ഉണ്ട്. ഇത് ഒരു വിവരത്തിൻ്റെ ലേബൽ, തലക്കെട്ട്, അല്ലെങ്കിൽ കീവേഡ് പോലെയാണ്. ഏറ്റവും പ്രസക്തമായവ കണ്ടെത്താൻ ക്വറി എല്ലാ കീകളുമായി താരതമ്യം ചെയ്യും.
• മൂല്യം (V): സീക്വൻസിലെ ഓരോ ഇനത്തിനും ഒരു മൂല്യ വെക്റ്റർ ഉണ്ട്. ഇതിൽ യഥാർത്ഥ ഉള്ളടക്കം അല്ലെങ്കിൽ വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ക്വറി മികച്ച മാച്ചിംഗ് കീകളെ കണ്ടെത്തിക്കഴിഞ്ഞാൽ, ഞങ്ങൾ അവയുടെ അനുബന്ധ മൂല്യങ്ങൾ വീണ്ടെടുക്കും.

സെൽഫ്-അറ്റൻഷനിൽ, ട്രാൻസ്ഫോർമറിൻ്റെ എൻകോഡറിനും ഡീകോഡറിനും ഉള്ളിൽ ഉപയോഗിക്കുന്ന സംവിധാനം, ക്വറികൾ, കീകൾ, മൂല്യങ്ങൾ എന്നിവയെല്ലാം ഒരേ ഇൻപുട്ട് സീക്വൻസിൽ നിന്ന് സൃഷ്ടിക്കപ്പെടുന്നു. വാക്യത്തിലെ ഓരോ വാക്കും മൂന്ന് പ്രത്യേക, പഠിച്ച ലീനിയർ ലെയറുകളിലൂടെ കടന്നുപോയി അതിൻ്റെ സ്വന്തം Q, K, V വെക്റ്ററുകൾ സൃഷ്ടിക്കുന്നു. ഇത് ഒരേ വാക്യത്തിലെ ഓരോ വാക്കും മറ്റെല്ലാ വാക്കുകളുമായും അറ്റൻഷൻ കണക്കാക്കാൻ മോഡലിനെ അനുവദിക്കുന്നു.

ഒരു ഘട്ടം ഘട്ടമായുള്ള നടപ്പാക്കൽ വിഭജനം

ഫോർമുലയുടെ പ്രവർത്തനങ്ങളിലൂടെ നമുക്ക് നടക്കാം, ഓരോ ഘട്ടത്തെയും അതിൻ്റെ ഉദ്ദേശ്യവുമായി ബന്ധിപ്പിച്ച്.

ഘട്ടം 1: സാമ്യത സ്കോറുകൾ കണക്കാക്കുക (Q * K^T)

ഓരോ ക്വറിയും ഓരോ കീയുമായി എത്രത്തോളം യോജിക്കുന്നു എന്ന് അളക്കുക എന്നതാണ് ആദ്യത്തെ ഘട്ടം. ഇത് ഓരോ ക്വറി വെക്റ്ററിനെയും ഓരോ കീ വെക്റ്ററിനെയും എടുത്ത് ഡോട്ട് പ്രൊഡക്റ്റ് എടുക്കുന്നതിലൂടെ ഞങ്ങൾ ഇത് കൈവരിക്കുന്നു. പ്രായോഗികമായി, ഇത് ഒരു സിംഗിൾ മാട്രിക്സ് ഗുണനത്തിലൂടെ മുഴുവൻ സീക്വൻസിനും കാര്യക്ഷമമായി ചെയ്യുന്നു: `Q` ഗുണിതം `K` യുടെ ട്രാൻസ്പോസ് (`K^T`).

• ഇൻപുട്ട്: ഒരു ക്വറി മാട്രിക്സ് `Q`യുടെ രൂപം `(sequence_length, d_q)` ഉം ഒരു കീ മാട്രിക്സ് `K`യുടെ രൂപം `(sequence_length, d_k)` ഉം. ശ്രദ്ധിക്കുക: `d_q` തുല്യമായിരിക്കണം `d_k`.
• പ്രവർത്തനം: `Q * K^T`
• ഔട്ട്പുട്ട്: ഒരു അറ്റൻഷൻ സ്കോർ മാട്രിക്സ് രൂപം `(sequence_length, sequence_length)`. ഈ മാട്രിക്സിലെ `(i, j)` ഘടകം `i`-ാമത്തെ വാക്കിനും (`query` ആയി) `j`-ാമത്തെ വാക്കിനും (`key` ആയി) ഇടയിലുള്ള യഥാർത്ഥ സാമ്യത സ്കോറിനെ പ്രതിനിധീകരിക്കുന്നു. ഉയർന്ന സ്കോർ ഒരു ശക്തമായ ബന്ധത്തെ സൂചിപ്പിക്കുന്നു.

ഘട്ടം 2: സ്കെയിൽ ( / √d_k )

ഇത് ഒരു നിർണായകവും എന്നാൽ ലളിതവുമായ സ്ഥിരത ഘട്ടമാണ്. യഥാർത്ഥ പ്രബന്ധത്തിൻ്റെ രചയിതാക്കൾ കീ ഡൈമെൻഷൻ `d_k` യുടെ വലിയ മൂല്യങ്ങൾക്ക്, ഡോട്ട് പ്രൊഡക്റ്റുകൾക്ക് വലിയ തോതിലുള്ള വർദ്ധനവ് ഉണ്ടാകാൻ സാധ്യതയുണ്ടെന്ന് കണ്ടെത്തി. ഈ വലിയ സംഖ്യകൾ സോഫ്റ്റ്മാക്സ് ഫംഗ്ഷനിലേക്ക് (നമ്മുടെ അടുത്ത ഘട്ടം) നൽകുമ്പോൾ, അവ അതിൻ്റെ ഗ്രേഡിയൻ്റുകൾ വളരെ ചെറുതായിരിക്കുന്ന പ്രദേശങ്ങളിലേക്ക് തള്ളാൻ സാധ്യതയുണ്ട്. വാനിഷിംഗ് ഗ്രേഡിയൻ്റുകൾ എന്നറിയപ്പെടുന്ന ഈ പ്രതിഭാസം മോഡലിനെ ട്രെയിൻ ചെയ്യാൻ ബുദ്ധിമുട്ടാക്കും.

ഇതിനെ പ്രതിരോധിക്കാൻ, കീ വെക്റ്ററുകളുടെ ഡൈമെൻഷന്റെ വർഗ്ഗമൂലം, √d_k, കൊണ്ട് അവയെ ഭാഗിച്ച് സ്കോറുകൾ സ്കെയിൽ ചെയ്യുന്നു. ഇത് സ്കോറുകളുടെ വ്യതിയാനം 1 ആയി നിലനിർത്തുന്നു, ട്രെയിനിംഗ് സമയത്ത് സ്ഥിരമായ ഗ്രേഡിയൻ്റുകൾ ഉറപ്പാക്കുന്നു.

ഘട്ടം 3: സോഫ്റ്റ്മാക്സ് പ്രയോഗിക്കുക (softmax(...))

ഇപ്പോൾ നമുക്ക് സ്കെയിൽ ചെയ്ത അലൈൻമെൻ്റ് സ്കോറുകളുടെ ഒരു മാട്രിക്സ് ലഭിച്ചു, പക്ഷേ ഈ സ്കോറുകൾ ക്രമരഹിതമാണ്. അവയെ വ്യാഖ്യാനിക്കാവുന്നതും ഉപയോഗപ്രദവുമാക്കാൻ, ഞങ്ങൾ ഓരോ വരിയിലും സോഫ്റ്റ്മാക്സ് ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നു. സോഫ്റ്റ്മാക്സ് ഫംഗ്ഷൻ രണ്ട് കാര്യങ്ങൾ ചെയ്യുന്നു:

1. എല്ലാ സ്കോറുകളെയും പോസിറ്റീവ് സംഖ്യകളാക്കി മാറ്റുന്നു.
2. ഓരോ വരിയിലെയും സ്കോറുകൾ 1 ആകുന്ന തരത്തിൽ അവയെ സാധാരണവൽക്കരിക്കുന്നു.

ഈ ഘട്ടത്തിൻ്റെ ഔട്ട്പുട്ട് അറ്റൻഷൻ വെയിറ്റുകളുടെ ഒരു മാട്രിക്സ് ആണ്. ഓരോ വരിയും ഇപ്പോൾ ഒരു പ്രോബബിലിറ്റി ഡിസ്ട്രിബ്യൂഷൻ പ്രതിനിധീകരിക്കുന്നു, ഓരോ വരിയുടെയും സ്ഥാനത്തെ വാക്ക് സീക്വൻസിലെ മറ്റ് വാക്കുകളിൽ എത്രത്തോളം ശ്രദ്ധ നൽകണം എന്ന് പറയുന്നു. "സഞ്ചരിച്ചു" എന്ന വരിയിലെ "കപ്പൽ" എന്ന വാക്കിനുള്ള 0.9 ഭാരം, "സഞ്ചരിച്ചു" എന്നതിൻ്റെ പുതിയ പ്രതിനിധാനം കണക്കാക്കുമ്പോൾ 90% വിവരങ്ങൾ "കപ്പൽ"യിൽ നിന്ന് വരുമെന്ന് അർത്ഥമാക്കുന്നു.

ഘട്ടം 4: വെയിറ്റഡ് സം കണക്കാക്കുക ( * V )

ഓരോ വാക്കിനും പുതിയ, സന്ദർഭ-ബോധമുള്ള പ്രതിനിധാനം സൃഷ്ടിക്കാൻ ഈ അറ്റൻഷൻ വെയിറ്റുകൾ ഉപയോഗിക്കുന്നതാണ് അവസാന ഘട്ടം. ഞങ്ങൾ അറ്റൻഷൻ വെയിറ്റുകളുടെ മാട്രിക്സ് `V` എന്ന മൂല്യ മാട്രിക്സുമായി ഗുണിക്കുന്നതിലൂടെ ഇത് ചെയ്യുന്നു.

• ഇൻപുട്ട്: അറ്റൻഷൻ വെയിറ്റുകളുടെ മാട്രിക്സ് `(sequence_length, sequence_length)` ഉം മൂല്യ മാട്രിക്സ് `V` `(sequence_length, d_v)` ഉം.
• പ്രവർത്തനം: `weights * V`
• ഔട്ട്പുട്ട്: ഒരു അവസാന ഔട്ട്പുട്ട് മാട്രിക്സ് രൂപം `(sequence_length, d_v)`.

ഓരോ വാക്കിനും (ഓരോ വരിയും), അതിൻ്റെ പുതിയ പ്രതിനിധാനം സീക്വൻസിലെ എല്ലാ മൂല്യ വെക്റ്ററുകളുടെയും ഒരു വെയിറ്റഡ് സം ആണ്. ഉയർന്ന അറ്റൻഷൻ വെയിറ്റുകളുള്ള വാക്കുകൾ ഈ സം에 കൂടുതൽ സംഭാവന നൽകുന്നു. ഫലം എംബെഡിംഗുകളുടെ ഒരു സെറ്റാണ്, അതിൽ ഓരോ വാക്കിൻ്റെയും വെക്റ്റർ അതിൻ്റെ സ്വന്തം അർത്ഥം മാത്രമല്ല, അത് ശ്രദ്ധിച്ച വാക്കുകളുടെ അർത്ഥങ്ങളുടെ ഒരു മിശ്രിതമാണ്. ഇത് ഇപ്പോൾ സന്ദർഭം കൊണ്ട് സമ്പന്നമാണ്.

പൈടോർച്ചിലെ ഒരു പ്രായോഗിക കോഡ് ഉദാഹരണം: സ്കെയിൽഡ് ഡോട്ട്-പ്രൊഡക്റ്റ് അറ്റൻഷൻ

സിദ്ധാന്തം പരിശീലനത്തിലൂടെ മികച്ചതായി മനസ്സിലാക്കുന്നു. ഡീപ് ലേണിംഗിനുള്ള ഒരു ജനപ്രിയ ഫ്രെയിംവർക്കായ പൈത്തണും പൈടോർച്ച് ലൈബ്രറിയും ഉപയോഗിച്ച് സ്കെയിൽഡ് ഡോട്ട്-പ്രൊഡക്റ്റ് അറ്റൻഷൻ മെക്കാനിസത്തിൻ്റെ ലളിതമായ, കമൻ്റ് ചെയ്ത നടപ്പാക്കൽ ഇതാ.

            
import torch
import torch.nn as nn
import math

class ScaledDotProductAttention(nn.Module):
    """ Implements the Scaled Dot-Product Attention mechanism. """
    def __init__(self):
        super(ScaledDotProductAttention, self).__init__()

    def forward(self, q, k, v, mask=None):
        # q, k, v must have the same dimension d_k = d_v = d_model / h
        # In practice, these tensors will also have a batch dimension and head dimension.
        # For clarity, let's assume shape [batch_size, num_heads, seq_len, d_k]
        
        d_k = k.size(-1)  # Get the dimension of the key vectors
        
        # 1. Calculate Similarity Scores: (Q * K^T)
        # Matmul for the last two dimensions: (seq_len, d_k) * (d_k, seq_len) -> (seq_len, seq_len)
        scores = torch.matmul(q, k.transpose(-2, -1))
        
        # 2. Scale the scores
        scaled_scores = scores / math.sqrt(d_k)
        
        # 3. (Optional) Apply mask to prevent attention to certain positions
        # The mask is crucial in the decoder to prevent attending to future tokens.
        if mask is not None:
            # Fills elements of self tensor with -1e9 where mask is True.
            scaled_scores = scaled_scores.masked_fill(mask == 0, -1e9)
        
        # 4. Apply Softmax to get attention weights
        # Softmax is applied on the last dimension (the keys) to get a distribution.
        attention_weights = torch.softmax(scaled_scores, dim=-1)
        
        # 5. Compute the Weighted Sum: (weights * V)
        # Matmul for the last two dimensions: (seq_len, seq_len) * (seq_len, d_v) -> (seq_len, d_v)
        output = torch.matmul(attention_weights, v)
        
        return output, attention_weights


            

              
                Copy
              
            
          

ലെവൽ അപ്പ്: മൾട്ടി-ഹെഡ് അറ്റൻഷൻ

സ്കെയിൽഡ് ഡോട്ട്-പ്രൊഡക്റ്റ് അറ്റൻഷൻ മെക്കാനിസം ശക്തമാണ്, പക്ഷേ അതിന് ഒരു പരിമിതിയുണ്ട്. ഇത് ഒരു സിംഗിൾ സെറ്റ് അറ്റൻഷൻ വെയിറ്റുകൾ കണക്കാക്കുന്നു, ഇത് അതിൻ്റെ ശ്രദ്ധയെ ശരാശരിയാക്കാൻ നിർബന്ധിതരാക്കുന്നു. ഒരു സിംഗിൾ അറ്റൻഷൻ മെക്കാനിസത്തിന്, ഉദാഹരണത്തിന്, വിഷയം-ക്രിയ ബന്ധങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ കഴിഞ്ഞേക്കും. എന്നാൽ മറ്റ് ബന്ധങ്ങൾ, പ്രോനോൺ-അൻ്റിസിഡൻ്റ്, അല്ലെങ്കിൽ ശൈലിപരമായ സൂക്ഷ്മതകൾ എന്നിവയെക്കുറിച്ച് എന്തെല്ലാം?

ഇവിടെയാണ് മൾട്ടി-ഹെഡ് അറ്റൻഷൻ വരുന്നത്. ഒരു സിംഗിൾ അറ്റൻഷൻ കണക്കുകൂട്ടൽ നടത്തുന്നതിനു പകരം, അത് അറ്റൻഷൻ മെക്കാനിസം ഒന്നിലധികം തവണ സമാന്തരമായി പ്രവർത്തിപ്പിച്ച് ഫലങ്ങൾ സംയോജിപ്പിക്കുന്നു.

"എന്തുകൊണ്ട്": വ്യത്യസ്ത ബന്ധങ്ങൾ പിടിച്ചെടുക്കുന്നു

ഇതിനെ ഒരു ജനറലിസ്റ്റിന് പകരം വിദഗ്ധരുടെ ഒരു കമ്മിറ്റി ഉള്ളതായി ചിന്തിക്കുക. മൾട്ടി-ഹെഡ് അറ്റൻഷനിലെ ഓരോ "ഹെഡ്"നും വ്യത്യസ്ത തരം ബന്ധങ്ങളിൽ അല്ലെങ്കിൽ ഇൻപുട്ട് ഡാറ്റയുടെ വശങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ പഠിക്കുന്ന ഒരു വിദഗ്ധനായി കണക്കാക്കാം.

വാക്യത്തിന്, "മൃഗം തെരുവ് കടന്നില്ല കാരണം അത് വളരെ ക്ഷീണിതനായിരുന്നു,"

• ഹെഡ് 1 പ്രോനോൺ "അത്" അതിൻ്റെ അൻ്റിസിഡൻ്റ് "മൃഗം" എന്നതിലേക്ക് ബന്ധിപ്പിക്കാൻ പഠിച്ചേക്കാം.
• ഹെഡ് 2 "കടന്നില്ല" എന്നതിനും "ക്ഷീണിതനായിരുന്നു" എന്നതിനും ഇടയിലുള്ള കാരണം-ഫലം ബന്ധം പഠിച്ചേക്കാം.
• ഹെഡ് 3 ക്രിയ "ആയിരുന്നു" അതിൻ്റെ വിഷയം "അത്" തമ്മിലുള്ള സിൻ്റാക്റ്റിക് ബന്ധം പിടിച്ചെടുത്തേക്കാം.

ഒന്നിലധികം ഹെഡുകൾ (യഥാർത്ഥ ട്രാൻസ്ഫോർമർ പേപ്പറിൽ 8 ഉപയോഗിച്ചു) ഉള്ളതിനാൽ, മോഡലിന് ഡാറ്റയിലെ വ്യത്യസ്ത വാക്യഘടന, അർത്ഥപരമായ ബന്ധങ്ങൾ ഒരേസമയം പിടിച്ചെടുക്കാൻ കഴിയും, ഇത് വളരെ സൂക്ഷ്മവും ശക്തവുമായ ഒരു പ്രതിനിധാനത്തിലേക്ക് നയിക്കുന്നു.

"എങ്ങനെ": വിഭജിക്കുക, ശ്രദ്ധിക്കുക, സംയോജിപ്പിക്കുക, പ്രൊജക്റ്റ് ചെയ്യുക

മൾട്ടി-ഹെഡ് അറ്റൻഷൻ നടപ്പാക്കൽ നാല് ഘട്ട പ്രക്രിയ പിന്തുടരുന്നു:

1. ലീനിയർ പ്രൊജക്ഷനുകൾ: ഇൻപുട്ട് എംബെഡിംഗുകൾ മൂന്ന് പ്രത്യേക ലീനിയർ ലെയറുകളിലൂടെ കടന്നുപോയി ആദ്യ ക്വറി, കീ, മൂല്യ മാട്രിക്സുകൾ സൃഷ്ടിക്കുന്നു. ഇവ തുടർന്ന് `h` ചെറിയ ഭാഗങ്ങളായി (ഓരോ ഹെഡിനും ഒന്ന്) വിഭജിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങളുടെ മോഡൽ ഡൈമെൻഷൻ `d_model` 512 ആണെങ്കിൽ, നിങ്ങൾക്ക് 8 ഹെഡുകൾ ഉണ്ടെങ്കിൽ, ഓരോ ഹെഡും 64 ഡൈമെൻഷനിലുള്ള Q, K, V വെക്റ്ററുകളുമായി പ്രവർത്തിക്കും (512 / 8).
2. സമാന്തര അറ്റൻഷൻ: ഞങ്ങൾ മുമ്പ് ചർച്ച ചെയ്ത സ്കെയിൽഡ് ഡോട്ട്-പ്രൊഡക്റ്റ് അറ്റൻഷൻ മെക്കാനിസം `h` സെറ്റ് Q, K, V സബ്സ്പേസുകളിൽ ഓരോന്നിലും സ്വതന്ത്രമായും സമാന്തരമായും പ്രയോഗിക്കുന്നു. ഇത് `h` പ്രത്യേക അറ്റൻഷൻ ഔട്ട്പുട്ട് മാട്രിക്സുകൾ സൃഷ്ടിക്കുന്നു.
3. സംയോജിപ്പിക്കുക: `h` ഔട്ട്പുട്ട് മാട്രിക്സുകൾ ഒരു വലിയ മാട്രിക്സിലേക്ക് സംയോജിപ്പിക്കുന്നു. നമ്മുടെ ഉദാഹരണത്തിൽ, 64 വലുപ്പമുള്ള 8 മാട്രിക്സുകൾ 512 വലുപ്പമുള്ള ഒരു മാട്രിക്സ് രൂപീകരിക്കുന്നതിന് സംയോജിപ്പിക്കും.
4. അന്തിമ പ്രൊജക്ഷൻ: ഈ സംയോജിപ്പിച്ച മാട്രിക്സ് ഒരു അവസാന ലീനിയർ ലെയറിലൂടെ കടന്നുപോകുന്നു. ഈ ലെയർ വ്യത്യസ്ത ഹെഡുകൾ പഠിച്ച വിവരങ്ങളെ എങ്ങനെ മികച്ച രീതിയിൽ സംയോജിപ്പിക്കാമെന്ന് മോഡലിനെ പഠിക്കാൻ അനുവദിക്കുന്നു, ഒരു ഏകീകൃത അന്തിമ ഔട്ട്പുട്ട് സൃഷ്ടിക്കുന്നു.

പൈടോർച്ചിലെ കോഡ് നടപ്പാക്കൽ: മൾട്ടി-ഹെഡ് അറ്റൻഷൻ

ഞങ്ങളുടെ മുമ്പത്തെ കോഡിൽ നിന്ന് നിർമ്മിച്ചുകൊണ്ട്, ഇവിടെ ഒരു സാധാരണ മൾട്ടി-ഹെഡ് അറ്റൻഷൻ ബ്ലോക്കിൻ്റെ നടപ്പാക്കൽ.

            
class MultiHeadAttention(nn.Module):
    """ Implements the Multi-Head Attention mechanism. """
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        
        self.d_model = d_model
        self.num_heads = num_heads
        self.d_k = d_model // num_heads
        
        # Linear layers for Q, K, V and the final output
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)
        
        self.attention = ScaledDotProductAttention()

    def forward(self, q, k, v, mask=None):
        batch_size = q.size(0)
        
        # 1. Apply linear projections
        q, k, v = self.W_q(q), self.W_k(k), self.W_v(v)
        
        # 2. Reshape for multi-head attention
        # (batch_size, seq_len, d_model) -> (batch_size, num_heads, seq_len, d_k)
        q = q.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        k = k.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        v = v.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        
        # 3. Apply attention on all heads in parallel
        context, _ = self.attention(q, k, v, mask=mask)
        
        # 4. Concatenate heads and apply final linear layer
        # (batch_size, num_heads, seq_len, d_k) -> (batch_size, seq_len, num_heads, d_k)
        context = context.transpose(1, 2).contiguous()
        # (batch_size, seq_len, num_heads, d_k) -> (batch_size, seq_len, d_model)
        context = context.view(batch_size, -1, self.d_model)
        
        output = self.W_o(context)
        
        return output


            

              
                Copy
              
            
          

ആഗോള സ്വാധീനം: ഈ മെക്കാനിസം ഒരു ഗെയിം-ചേഞ്ചർ ആകുന്നത് എന്തുകൊണ്ട്

അറ്റൻഷൻ്റെ തത്വങ്ങൾ നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗിൽ മാത്രം പരിമിതമല്ല. ഈ മെക്കാനിസം വിവിധ മേഖലകളിൽ ഒരു ബഹുമുഖവും ശക്തവുമായ ഉപകരണമായി തെളിയിച്ചിട്ടുണ്ട്, ഇത് ആഗോള തലത്തിൽ പുരോഗതിക്ക് കാരണമാകുന്നു.

• ഭാഷാ തടസ്സങ്ങൾ തകർക്കുന്നു: മെഷീൻ ട്രാൻസ്ലേഷനിൽ, വ്യത്യസ്ത ഭാഷകളിലെ വാക്കുകൾക്കിടയിൽ നേരിട്ടുള്ള, നോൺ-ലീനിയർ അലൈൻമെൻ്റുകൾ സൃഷ്ടിക്കാൻ അറ്റൻഷൻ ഒരു മോഡലിനെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, ഫ്രഞ്ച് പദസഞ്ചയം "la voiture bleue" യെ ഇംഗ്ലീഷ് "the blue car" യുമായി ശരിയായി മാപ്പ് ചെയ്യാൻ ഇതിന് കഴിയും, വ്യത്യസ്ത പ്രത്യേക സ്ഥാനങ്ങൾ മനോഹരമായി കൈകാര്യം ചെയ്യുന്നു.
• തിരയലും സംഗ്രഹിക്കലും ശക്തമാക്കുന്നു: ഒരു നീണ്ട ഡോക്യുമെൻ്റ് സംഗ്രഹിക്കുകയോ അതിനെക്കുറിച്ച് ഒരു ചോദ്യത്തിന് ഉത്തരം നൽകുകയോ പോലുള്ള ജോലികൾക്ക്, സെൽഫ്-അറ്റൻഷൻ ഏറ്റവും പ്രധാനപ്പെട്ട വാക്യങ്ങളും ആശയങ്ങളും തിരിച്ചറിയാൻ ഒരു മോഡലിനെ സഹായിക്കുന്നു, അവയ്ക്കിടയിലുള്ള സങ്കീർണ്ണമായ ബന്ധങ്ങളുടെ വെബ് മനസ്സിലാക്കുന്നു.
• ശാസ്ത്രത്തെയും വൈദ്യശാസ്ത്രത്തെയും മുന്നോട്ട് കൊണ്ടുപോകുന്നു: ടെക്സ്റ്റിന് പുറമെ, സങ്കീർണ്ണമായ ശാസ്ത്രീയ ഡാറ്റയിലെ ഇടപെടലുകൾ മോഡൽ ചെയ്യാൻ അറ്റൻഷൻ ഉപയോഗിക്കുന്നു. ജനിതകശാസ്ത്രത്തിൽ, ഇത് ഡിഎൻഎ സ്ട്രാൻഡിലെ വിദൂര ബേസ് ജോഡികൾക്കിടയിലുള്ള ആശ്രിതത്വം മോഡൽ ചെയ്യാൻ കഴിയും. ഡ്രഗ് ഡിസ്കവറിയിൽ, പ്രോട്ടീനുകൾക്കിടയിലുള്ള ഇടപെടലുകൾ പ്രവചിക്കാൻ ഇത് സഹായിക്കുന്നു, പുതിയ ചികിത്സകളിലേക്കുള്ള ഗവേഷണം വേഗത്തിലാക്കുന്നു.
• കമ്പ്യൂട്ടർ വിഷൻ വിപ്ലവവൽക്കരിക്കുന്നു: വിഷൻ ട്രാൻസ്ഫോർമറുകളുടെ (ViT) ആവിർഭാവത്തോടെ, അറ്റൻഷൻ മെക്കാനിസം ഇപ്പോൾ ആധുനിക കമ്പ്യൂട്ടർ വിഷൻ്റെ ഒരു അടിസ്ഥാന ശിലയാണ്. ഒരു ചിത്രത്തെ പാച്ചുകളുടെ ഒരു സീക്വൻസായി പരിഗണിച്ച്, സെൽഫ്-അറ്റൻഷൻ ഒരു ചിത്രത്തിൻ്റെ വ്യത്യസ്ത ഭാഗങ്ങൾക്കിടയിലുള്ള ബന്ധങ്ങൾ മനസ്സിലാക്കാൻ ഒരു മോഡലിനെ അനുവദിക്കുന്നു, ഇത് ഇമേജ് ക്ലാസിഫിക്കേഷനിലും ഒബ്ജക്റ്റ് ഡിറ്റക്ഷനിലും അത്യാധുനിക പ്രകടനം കാഴ്ചവെക്കുന്നു.

ഉപസംഹാരം: ഭാവിക്കാലം ശ്രദ്ധാലുവാണ്

ശ്രദ്ധയുടെ Intutive ആശയത്തിൽ നിന്ന് മൾട്ടി-ഹെഡ് അറ്റൻഷൻ്റെ പ്രായോഗിക നടപ്പാക്കലിലേക്കുള്ള യാത്ര, ശക്തവും അതാര്യവുമായ ഒരു മെക്കാനിസം വെളിപ്പെടുത്തുന്നു. ഇത് AI മോഡലുകളെ വിവരങ്ങൾ ഒരു കർശനമായ സീക്വൻസായി പ്രോസസ്സ് ചെയ്യാൻ അനുവദിച്ചു, അല്ലാതെ ഒരു വഴക്കമുള്ള, പരസ്പരം ബന്ധിപ്പിച്ചിരിക്കുന്ന ബന്ധങ്ങളുടെ ശൃംഖലയായി. ട്രാൻസ്ഫോർമർ ആർക്കിടെക്ചർ അവതരിപ്പിച്ച ഈ കാഴ്ചപ്പാടിലെ മാറ്റം, AIയിൽ അഭൂതപൂർവമായ കഴിവുകൾ അൺലോക്ക് ചെയ്തു.

എങ്ങനെ നടപ്പിലാക്കാമെന്നും വ്യാഖ്യാനിക്കാമെന്നും മനസ്സിലാക്കുന്നതിലൂടെ, നിങ്ങൾ ആധുനിക AIയുടെ അടിസ്ഥാന ബിൽഡിംഗ് ബ്ലോക്ക് മനസ്സിലാക്കുന്നു. ഗവേഷണം പരിണമിക്കുന്നത് തുടരുമ്പോൾ, പുതിയതും കൂടുതൽ കാര്യക്ഷമവുമായ അറ്റൻഷൻ വേരിയൻ്റുകൾ നിസ്സംശയം ഉയർന്നുവരും, എന്നാൽ ഏറ്റവും പ്രധാനപ്പെട്ട കാര്യങ്ങളിൽ ശ്രദ്ധയോടെ തിരഞ്ഞെടുത്ത് ശ്രദ്ധ കേന്ദ്രീകരിക്കാനുള്ള പ്രധാന തത്വം, കൂടുതൽ ബുദ്ധിമാനും കഴിവുറ്റതുമായ സിസ്റ്റങ്ങൾക്കായുള്ള തുടർച്ചയായ അന്വേഷണത്തിൽ ഒരു കേന്ദ്ര വിഷയമായി നിലനിൽക്കും.